home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / StringIO.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  380 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """File-like objects that read from or write to a string buffer.
  5.  
  6. This implements (nearly) all stdio methods.
  7.  
  8. f = StringIO()      # ready for writing
  9. f = StringIO(buf)   # ready for reading
  10. f.close()           # explicitly release resources held
  11. flag = f.isatty()   # always false
  12. pos = f.tell()      # get current position
  13. f.seek(pos)         # set current position
  14. f.seek(pos, mode)   # mode 0: absolute; 1: relative; 2: relative to EOF
  15. buf = f.read()      # read until EOF
  16. buf = f.read(n)     # read up to n bytes
  17. buf = f.readline()  # read until end of line ('\\n') or EOF
  18. list = f.readlines()# list of f.readline() results until EOF
  19. f.truncate([size])  # truncate file at to at most size (default: current pos)
  20. f.write(buf)        # write at current position
  21. f.writelines(list)  # for line in list: f.write(line)
  22. f.getvalue()        # return whole file's contents as a string
  23.  
  24. Notes:
  25. - Using a real file is often faster (but less convenient).
  26. - There's also a much faster implementation in C, called cStringIO, but
  27.   it's not subclassable.
  28. - fileno() is left unimplemented so that code which uses it triggers
  29.   an exception early.
  30. - Seeking far beyond EOF and then writing will insert real null
  31.   bytes that occupy space in the buffer.
  32. - There's a simple test set (see end of this file).
  33. """
  34.  
  35. try:
  36.     from errno import EINVAL
  37. except ImportError:
  38.     EINVAL = 22
  39.  
  40. __all__ = [
  41.     'StringIO']
  42.  
  43. def _complain_ifclosed(closed):
  44.     if closed:
  45.         raise ValueError, 'I/O operation on closed file'
  46.     
  47.  
  48.  
  49. class StringIO:
  50.     '''class StringIO([buffer])
  51.  
  52.     When a StringIO object is created, it can be initialized to an existing
  53.     string by passing the string to the constructor. If no string is given,
  54.     the StringIO will start empty.
  55.  
  56.     The StringIO object can accept either Unicode or 8-bit strings, but
  57.     mixing the two may take some care. If both are used, 8-bit strings that
  58.     cannot be interpreted as 7-bit ASCII (that use the 8th bit) will cause
  59.     a UnicodeError to be raised when getvalue() is called.
  60.     '''
  61.     
  62.     def __init__(self, buf = ''):
  63.         if not isinstance(buf, basestring):
  64.             buf = str(buf)
  65.         
  66.         self.buf = buf
  67.         self.len = len(buf)
  68.         self.buflist = []
  69.         self.pos = 0
  70.         self.closed = False
  71.         self.softspace = 0
  72.  
  73.     
  74.     def __iter__(self):
  75.         return self
  76.  
  77.     
  78.     def next(self):
  79.         '''A file object is its own iterator, for example iter(f) returns f
  80.         (unless f is closed). When a file is used as an iterator, typically
  81.         in a for loop (for example, for line in f: print line), the next()
  82.         method is called repeatedly. This method returns the next input line,
  83.         or raises StopIteration when EOF is hit.
  84.         '''
  85.         if self.closed:
  86.             raise StopIteration
  87.         
  88.         r = self.readline()
  89.         if not r:
  90.             raise StopIteration
  91.         
  92.         return r
  93.  
  94.     
  95.     def close(self):
  96.         '''Free the memory buffer.
  97.         '''
  98.         if not self.closed:
  99.             self.closed = True
  100.             del self.buf
  101.             del self.pos
  102.         
  103.  
  104.     
  105.     def isatty(self):
  106.         '''Returns False because StringIO objects are not connected to a
  107.         tty-like device.
  108.         '''
  109.         _complain_ifclosed(self.closed)
  110.         return False
  111.  
  112.     
  113.     def seek(self, pos, mode = 0):
  114.         """Set the file's current position.
  115.  
  116.         The mode argument is optional and defaults to 0 (absolute file
  117.         positioning); other values are 1 (seek relative to the current
  118.         position) and 2 (seek relative to the file's end).
  119.  
  120.         There is no return value.
  121.         """
  122.         _complain_ifclosed(self.closed)
  123.         if self.buflist:
  124.             self.buf += ''.join(self.buflist)
  125.             self.buflist = []
  126.         
  127.         if mode == 1:
  128.             pos += self.pos
  129.         elif mode == 2:
  130.             pos += self.len
  131.         
  132.         self.pos = max(0, pos)
  133.  
  134.     
  135.     def tell(self):
  136.         """Return the file's current position."""
  137.         _complain_ifclosed(self.closed)
  138.         return self.pos
  139.  
  140.     
  141.     def read(self, n = -1):
  142.         '''Read at most size bytes from the file
  143.         (less if the read hits EOF before obtaining size bytes).
  144.  
  145.         If the size argument is negative or omitted, read all data until EOF
  146.         is reached. The bytes are returned as a string object. An empty
  147.         string is returned when EOF is encountered immediately.
  148.         '''
  149.         _complain_ifclosed(self.closed)
  150.         if self.buflist:
  151.             self.buf += ''.join(self.buflist)
  152.             self.buflist = []
  153.         
  154.         if n < 0:
  155.             newpos = self.len
  156.         else:
  157.             newpos = min(self.pos + n, self.len)
  158.         r = self.buf[self.pos:newpos]
  159.         self.pos = newpos
  160.         return r
  161.  
  162.     
  163.     def readline(self, length = None):
  164.         """Read one entire line from the file.
  165.  
  166.         A trailing newline character is kept in the string (but may be absent
  167.         when a file ends with an incomplete line). If the size argument is
  168.         present and non-negative, it is a maximum byte count (including the
  169.         trailing newline) and an incomplete line may be returned.
  170.  
  171.         An empty string is returned only when EOF is encountered immediately.
  172.  
  173.         Note: Unlike stdio's fgets(), the returned string contains null
  174.         characters ('\x00') if they occurred in the input.
  175.         """
  176.         _complain_ifclosed(self.closed)
  177.         if self.buflist:
  178.             self.buf += ''.join(self.buflist)
  179.             self.buflist = []
  180.         
  181.         i = self.buf.find('\n', self.pos)
  182.         if i < 0:
  183.             newpos = self.len
  184.         else:
  185.             newpos = i + 1
  186.         if length is not None:
  187.             if self.pos + length < newpos:
  188.                 newpos = self.pos + length
  189.             
  190.         
  191.         r = self.buf[self.pos:newpos]
  192.         self.pos = newpos
  193.         return r
  194.  
  195.     
  196.     def readlines(self, sizehint = 0):
  197.         '''Read until EOF using readline() and return a list containing the
  198.         lines thus read.
  199.  
  200.         If the optional sizehint argument is present, instead of reading up
  201.         to EOF, whole lines totalling approximately sizehint bytes (or more
  202.         to accommodate a final whole line).
  203.         '''
  204.         total = 0
  205.         lines = []
  206.         line = self.readline()
  207.         while line:
  208.             lines.append(line)
  209.             total += len(line)
  210.             if sizehint < sizehint:
  211.                 pass
  212.             elif sizehint <= total:
  213.                 break
  214.             
  215.             line = self.readline()
  216.             continue
  217.             0
  218.         return lines
  219.  
  220.     
  221.     def truncate(self, size = None):
  222.         """Truncate the file's size.
  223.  
  224.         If the optional size argument is present, the file is truncated to
  225.         (at most) that size. The size defaults to the current position.
  226.         The current file position is not changed unless the position
  227.         is beyond the new file size.
  228.  
  229.         If the specified size exceeds the file's current size, the
  230.         file remains unchanged.
  231.         """
  232.         _complain_ifclosed(self.closed)
  233.         if size is None:
  234.             size = self.pos
  235.         elif size < 0:
  236.             raise IOError(EINVAL, 'Negative size not allowed')
  237.         elif size < self.pos:
  238.             self.pos = size
  239.         
  240.         self.buf = self.getvalue()[:size]
  241.         self.len = size
  242.  
  243.     
  244.     def write(self, s):
  245.         '''Write a string to the file.
  246.  
  247.         There is no return value.
  248.         '''
  249.         _complain_ifclosed(self.closed)
  250.         if not s:
  251.             return None
  252.         
  253.         if not isinstance(s, basestring):
  254.             s = str(s)
  255.         
  256.         spos = self.pos
  257.         slen = self.len
  258.         if spos == slen:
  259.             self.buflist.append(s)
  260.             self.len = self.pos = spos + len(s)
  261.             return None
  262.         
  263.         if spos > slen:
  264.             self.buflist.append('\x00' * (spos - slen))
  265.             slen = spos
  266.         
  267.         newpos = spos + len(s)
  268.         if spos < slen:
  269.             if self.buflist:
  270.                 self.buf += ''.join(self.buflist)
  271.             
  272.             self.buflist = [
  273.                 self.buf[:spos],
  274.                 s,
  275.                 self.buf[newpos:]]
  276.             self.buf = ''
  277.             if newpos > slen:
  278.                 slen = newpos
  279.             
  280.         else:
  281.             self.buflist.append(s)
  282.             slen = newpos
  283.         self.len = slen
  284.         self.pos = newpos
  285.  
  286.     
  287.     def writelines(self, iterable):
  288.         '''Write a sequence of strings to the file. The sequence can be any
  289.         iterable object producing strings, typically a list of strings. There
  290.         is no return value.
  291.  
  292.         (The name is intended to match readlines(); writelines() does not add
  293.         line separators.)
  294.         '''
  295.         write = self.write
  296.         for line in iterable:
  297.             write(line)
  298.         
  299.  
  300.     
  301.     def flush(self):
  302.         '''Flush the internal buffer
  303.         '''
  304.         _complain_ifclosed(self.closed)
  305.  
  306.     
  307.     def getvalue(self):
  308.         '''
  309.         Retrieve the entire contents of the "file" at any time before
  310.         the StringIO object\'s close() method is called.
  311.  
  312.         The StringIO object can accept either Unicode or 8-bit strings,
  313.         but mixing the two may take some care. If both are used, 8-bit
  314.         strings that cannot be interpreted as 7-bit ASCII (that use the
  315.         8th bit) will cause a UnicodeError to be raised when getvalue()
  316.         is called.
  317.         '''
  318.         if self.buflist:
  319.             self.buf += ''.join(self.buflist)
  320.             self.buflist = []
  321.         
  322.         return self.buf
  323.  
  324.  
  325.  
  326. def test():
  327.     import sys as sys
  328.     if sys.argv[1:]:
  329.         file = sys.argv[1]
  330.     else:
  331.         file = '/etc/passwd'
  332.     lines = open(file, 'r').readlines()
  333.     text = open(file, 'r').read()
  334.     f = StringIO()
  335.     for line in lines[:-2]:
  336.         f.write(line)
  337.     
  338.     f.writelines(lines[-2:])
  339.     if f.getvalue() != text:
  340.         raise RuntimeError, 'write failed'
  341.     
  342.     length = f.tell()
  343.     print 'File length =', length
  344.     f.seek(len(lines[0]))
  345.     f.write(lines[1])
  346.     f.seek(0)
  347.     print 'First line =', repr(f.readline())
  348.     print 'Position =', f.tell()
  349.     line = f.readline()
  350.     print 'Second line =', repr(line)
  351.     f.seek(-len(line), 1)
  352.     line2 = f.read(len(line))
  353.     if line != line2:
  354.         raise RuntimeError, 'bad result after seek back'
  355.     
  356.     f.seek(len(line2), 1)
  357.     list = f.readlines()
  358.     line = list[-1]
  359.     f.seek(f.tell() - len(line))
  360.     line2 = f.read()
  361.     if line != line2:
  362.         raise RuntimeError, 'bad result after seek back from EOF'
  363.     
  364.     print 'Read', len(list), 'more lines'
  365.     print 'File length =', f.tell()
  366.     if f.tell() != length:
  367.         raise RuntimeError, 'bad length'
  368.     
  369.     f.truncate(length / 2)
  370.     f.seek(0, 2)
  371.     print 'Truncated length =', f.tell()
  372.     if f.tell() != length / 2:
  373.         raise RuntimeError, 'truncate did not adjust length'
  374.     
  375.     f.close()
  376.  
  377. if __name__ == '__main__':
  378.     test()
  379.  
  380.